home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / print.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  9KB  |  447 lines
  1. /*
  2.  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
  3.  *
  4.  *  This program is free software; you can redistribute it and/or modify
  5.  *  it under the terms of the GNU General Public License as published by
  6.  *  the Free Software Foundation; either version 2 of the License, or
  7.  *  (at your option) any later version.
  8.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  *
  18.  */
  19.  
  20. #include "mutt.h"
  21. #include "mutt_curses.h"
  22. #include "rfc2047.h"
  23. #include "send.h"
  24. #include "mailbox.h"
  25. #include "parse.h"
  26. #include "copy.h"
  27.  
  28.  
  29.  
  30. #ifdef _PGPPATH
  31. #include "pgp.h"
  32. #endif /* _PGPPATH */
  33.  
  34.  
  35. #include <sys/wait.h>
  36. #include <string.h>
  37.  
  38. static char *get_line (FILE *fl, char *buf, size_t *blen, int decode)
  39. {
  40.   long old_pos;
  41.   int ch;
  42.  
  43.   if (!buf)
  44.   {
  45.     *blen = HUGE_STRING;
  46.     buf = (char *) safe_calloc (1, *blen);
  47.   }
  48.  
  49.   old_pos = ftell (fl);
  50.  
  51.   if ((fgets (buf, *blen - 1, fl)) == NULL)
  52.   {
  53.     buf[0] = 0;
  54.     return (buf);
  55.   }
  56.  
  57.   if (decode)
  58.   {
  59.     if (strncasecmp (buf, "Subject:", 8) == 0)
  60.     {
  61.       /* check to see if the next line is a continuation line */
  62.       ch = fgetc (fl);
  63.       ungetc (ch, fl);
  64.       if (ch == ' ' || ch == '\t')
  65.       {
  66.     fseek (fl, old_pos, 0);
  67.     buf = mutt_read_rfc822_line (fl, buf, blen);
  68.     if (buf && strlen (buf) == *blen - 1)
  69.       safe_realloc ((void **) &buf, (*blen += 16));
  70.     strcat (buf, "\n");
  71.       }
  72.     }
  73.  
  74.     rfc2047_decode (buf, buf, *blen);
  75.   }
  76.  
  77.   return (buf);
  78. }
  79.  
  80. /* Ok, the only reason for not merging this with mutt_copy_header()
  81.  * below is to avoid creating a HEADER structure in message_handler().
  82.  */
  83. int mutt_copy_hdr (FILE *in, FILE *out, long off_start, long off_end, int flags)
  84. {
  85.   int ignore = 0, from = 0;
  86.   char *buf = NULL;
  87.   size_t blen = 0;
  88.  
  89.   if (ftell (in) != off_start)
  90.     fseek (in, off_start, 0);
  91.  
  92.   /* If we are re-ordering, we have to scan the headers once
  93.    * to collect the headers we wish to re-order, then print them
  94.    * out, then print out the remaining headers.
  95.    */
  96.   if (flags & CH_REORDER)
  97.   {
  98.     LIST *t = NULL;
  99.     char **headers = NULL;
  100.     int hdr_count = 0;
  101.     int x = 0;
  102.     int match = FALSE;
  103.     int error = FALSE;
  104.  
  105.     for (t = HeaderOrderList; t; t = t->next)
  106.     {
  107.       dprint(1, (debugfile, "Reorder list: %s\n", t->data));
  108.       hdr_count++;
  109.     }
  110.  
  111.     /* if there are no headers in the re-order list, skip this */
  112.     if (hdr_count)
  113.     {
  114.       headers = safe_calloc (hdr_count, sizeof (char *));
  115.  
  116.       while (ftell (in) < off_end)
  117.       {
  118.     if ((buf = get_line (in, buf, &blen, (flags & CH_DECODE))) == NULL ||
  119.                                   buf[0] == 0)
  120.       break;
  121.  
  122.     if (match && (buf[0] == ' ' || buf[0] == '\t'))
  123.     {
  124.       char *hdr = headers[x];
  125.  
  126.       safe_realloc ((void **) &hdr,
  127.           strlen (headers[x]) + strlen (buf) + sizeof (char));
  128.       headers[x] = hdr;
  129.       strcat (headers[x], buf);
  130.       continue;
  131.     } 
  132.     else 
  133.       match = FALSE;
  134.  
  135.     if (!from && strncmp ("From ", buf, 5) == 0)
  136.     {
  137.       if ((flags & CH_FROM) == 0)
  138.         continue;
  139.       from = 1;
  140.     }
  141.     else if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
  142.       break; /* end of header */
  143.  
  144.     if (flags & CH_WEED)
  145.     {
  146.       if (buf[0] == ' ' || buf[0] == '\t')
  147.       {
  148.         if (ignore)
  149.           continue;
  150.       }
  151.       else if (mutt_matches_ignore (buf, Ignore) &&
  152.           !mutt_matches_ignore (buf, UnIgnore))
  153.         ignore = 1;
  154.       else
  155.         ignore = 0;
  156.     }
  157.  
  158.     if (!ignore)
  159.     {
  160.       t = HeaderOrderList;
  161.       x = 0;
  162.       match = FALSE;
  163.       while (t && !match)
  164.       {
  165.         if (!strncasecmp (buf, t->data, strlen (t->data)))
  166.         {
  167.           if (!headers[x])
  168.         headers[x] = safe_strdup (buf);
  169.           else
  170.           {
  171.         char *hdr = headers[x];
  172.         safe_realloc ((void **) &hdr,
  173.             strlen (headers[x]) + strlen (buf) + sizeof(char));
  174.         headers[x] = hdr;
  175.         strcat (headers[x], buf);
  176.           }
  177.  
  178.           dprint(2, (debugfile, "Reorder: %s matches %s\n", t->data, 
  179.           headers[x]));
  180.           match = TRUE;
  181.         }
  182.         else
  183.         {
  184.           t = t->next;
  185.           x++;
  186.         }
  187.       }
  188.     }
  189.       }
  190.  
  191.       for (x = 0; x < hdr_count; x++)
  192.       {
  193.     if (headers[x])
  194.     {
  195.       if (fputs (headers[x], out) == EOF)
  196.         error = TRUE;
  197.       safe_free ((void **) &headers[x]);
  198.     }
  199.       }
  200.  
  201.       safe_free ((void **) &headers);
  202.       if (error)
  203.       {
  204.     if (buf)
  205.       safe_free ((void **) &buf);
  206.     return (-1);
  207.       }
  208.  
  209.       from = 0;
  210.       ignore = 0;
  211.       fseek (in, off_start, 0);
  212.     } /* end hdr_count */
  213.   } /* end CH_REORDER */
  214.  
  215.   dprint (1, (debugfile, "WEED is %s\n", (flags & CH_WEED) ? "Set" : "Not"));
  216.   while (ftell (in) < off_end)
  217.   {
  218.     if ((buf = get_line (in, buf, &blen, (flags & CH_DECODE))) == NULL ||
  219.                                 buf[0] == 0)
  220.       break;
  221.  
  222.     if (!from && strncmp ("From ", buf, 5) == 0)
  223.     {
  224.       if ((flags & CH_FROM) == 0)
  225.     continue;
  226.       from = 1;
  227.     }
  228.     else if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
  229.       break; /* end of header */
  230.  
  231.     if (flags & CH_WEED)
  232.     {
  233.       if (buf[0] == ' ' || buf[0] == '\t')
  234.       {
  235.     if (ignore)
  236.       continue;
  237.       }
  238.       else if (mutt_matches_ignore (buf, Ignore) &&
  239.            !mutt_matches_ignore (buf, UnIgnore))
  240.     ignore = 1;
  241.       else
  242.     ignore = 0;
  243.     }
  244.     
  245.     if (!ignore)
  246.     {
  247.       if ((flags & (CH_UPDATE | CH_XMIT | CH_NOSTATUS)) &&
  248.       (strncasecmp ("Status:", buf, 7) == 0 ||
  249.        strncasecmp ("X-Status:", buf, 9) == 0))
  250.     continue;
  251.       if ((flags & (CH_UPDATE_LEN | CH_XMIT)) &&
  252.       (strncasecmp ("Content-Length:", buf, 15) == 0 ||
  253.        strncasecmp ("Lines:", buf, 6) == 0))
  254.     continue;
  255.       if ((flags & CH_MIME) &&
  256.       ((strncasecmp ("content-", buf, 8) == 0 &&
  257.         (strncasecmp ("transfer-encoding:", buf + 8, 18) == 0 ||
  258.          strncasecmp ("type:", buf + 8, 5) == 0)) ||
  259.        strncasecmp ("mime-version:", buf, 13) == 0))
  260.       {
  261.     /* content-type could be multi-line, so set ignore mode */
  262.     ignore = 1;
  263.     continue;
  264.       }
  265.  
  266.       /* Skip lines which were re-ordered */
  267.       if (flags & CH_REORDER)
  268.       {
  269.     LIST *t;
  270.     int match = FALSE;
  271.  
  272.     t = HeaderOrderList;
  273.     match = FALSE;
  274.     while (t && !match)
  275.     {
  276.       if (!strncasecmp (buf, t->data, strlen (t->data)))
  277.         match = TRUE;
  278.       else
  279.         t = t->next;
  280.     }
  281.     if (match)
  282.     {
  283.       ignore = 1;
  284.       continue;
  285.     }
  286.       }
  287.  
  288.       if (flags & CH_PREFIX)
  289.       {
  290.     if (fputs (Prefix, out) == EOF)
  291.     {
  292.       if (buf)
  293.         safe_free ((void **) &buf);
  294.       return (-1);
  295.     }
  296.       }
  297.  
  298.       if (fputs (buf, out) == EOF)
  299.       {
  300.     if (buf)
  301.       safe_free ((void **) &buf);
  302.     return (-1);
  303.       }
  304.     }
  305.   }
  306.  
  307.   if (buf)
  308.     safe_free ((void **) &buf);
  309.   return (0);
  310. }
  311.  
  312. /* flags
  313.  *    CH_WEED        do header weeding
  314.  *    CH_DECODE    RFC2047 header decoding
  315.  *    CH_PREFIX    quote header with $indent_str
  316.  *    CH_NOSTATUS    ignore the Status: and X-Status:
  317.  *    CH_REORDER    output header in order specified by `hdr_order'
  318.  *    CH_XMIT        ignore Lines: and Content-Length:
  319.  *    CH_MIME        ignore MIME fields
  320.  *    CH_UPDATE    write new Status: and X-Status:
  321.  *    CH_UPDATE_LEN    write new Content-Length: and Lines:
  322.  *    CH_NONEWLINE    don't output a newline after the header
  323.  */
  324. int mutt_copy_header (FILE *in, HEADER *h, FILE *out, int flags)
  325. {
  326.   if (mutt_copy_hdr (in, out, h->offset, h->content->offset, flags) == -1)
  327.     return (-1);
  328.  
  329.   if (flags & CH_UPDATE)
  330.   {
  331.     if ((flags & CH_NOSTATUS) == 0)
  332.     {
  333.       if (h->old || h->read)
  334.       {
  335.     if (fputs ("Status: ", out) == EOF)
  336.       return (-1);
  337.  
  338.     if (h->read)
  339.     {
  340.       if (fputs ("RO", out) == EOF)
  341.         return (-1);
  342.     }
  343.     else if (h->old)
  344.     {
  345.       if (fputc ('O', out) == EOF)
  346.         return (-1);
  347.     }
  348.  
  349.     if (fputc ('\n', out) == EOF)
  350.       return (-1);
  351.       }
  352.  
  353.       if (h->flagged || h->replied)
  354.       {
  355.     if (fputs ("X-Status: ", out) == EOF)
  356.       return (-1);
  357.  
  358.     if (h->replied)
  359.     {
  360.       if (fputc ('A', out) == EOF)
  361.         return (-1);
  362.     }
  363.  
  364.     if (h->flagged)
  365.     {
  366.       if (fputc ('F', out) == EOF)
  367.         return (-1);
  368.     }
  369.     
  370.     if (fputc ('\n', out) == EOF)
  371.       return (-1);
  372.       }
  373.     }
  374.   }
  375.  
  376.   if (flags & CH_UPDATE_LEN)
  377.   {
  378.     fprintf (out, "Content-Length: %ld\n", h->content->length);
  379.     if (h->lines != 0 || h->content->length == 0)
  380.       fprintf (out, "L